{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## Python：jieba库的介绍与使用\n",
    "\n",
    "## **前言：**\n",
    "\n",
    "jieba是优秀的中文分词第三方库，由于中文文本之间每个汉字都是连续书写的，我们需要通过特定的手段来获得其中的每个词组，这种手段叫做分词，我们可以通过jieba库来完成这个过程。\n",
    "\n",
    "\n",
    "\n",
    "## 一、jieba库基本介绍\n",
    "\n",
    "(1)jieba库概述\n",
    "\n",
    "① jieba是优秀的中文分词第三方库\n",
    "\n",
    "②中文文本需要通过分词获得单个的词语③ jieba是优秀的中文分词第三方库，需要额外安装           \n",
    "\n",
    "④jieba库提供三种分词模式，最简单只需掌握一个函数\n",
    "\n",
    " (2)jieba分词的原理\n",
    "\n",
    "①分词依靠中文词库\n",
    "\n",
    "②  利用一个中文词库，确定汉字之间的关联概率\n",
    "\n",
    "③ 汉字间概率大的组成词组，形成分词结果\n",
    "\n",
    "④ 除了分词，用户还可以添加自定义的词组\n",
    "\n",
    "## 二、jieba库使用说明\n",
    "\n",
    " (1)jieba分词的三种模式\n",
    "\n",
    "       精确模式、全模式、搜索引擎模式"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "①jieba.cun(s)精确模式：就是把一段文本精确地切分成若干个中文单词，若干个中文单词之间经过组合，就精确地还原为之前的文本。其中不存在冗余单词。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "中国,是,一个,伟大,的,国家,"
     ]
    }
   ],
   "source": [
    "import jieba\n",
    "\n",
    "s = \"中国是一个伟大的国家\"\n",
    "for i in jieba.cut(s, cut_all=False, use_paddle=True):\n",
    "    print(i, end=',')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "\n",
    "② jieba.lcut(s,cut\\_all=True) 全模式：把文本中所有可能的词语都扫描出来，有冗余:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": "['中国', '国是', '一个', '伟大', '的', '国家']"
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = \"中国是一个伟大的国家\"\n",
    "jieba.lcut(s, cut_all=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "\n",
    "\n",
    "③jieba.lcut\\_for\\_search(s) 搜索引擎模式：在精确模式基础上，对长词再次切分:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['中华', '华人', '人民', '共和', '共和国', '中华人民共和国']"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = \"中华人民共和国\"\n",
    "jieba.lcut_for_search(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "source": [],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "\n",
    "### 三、jieba库的安装\n",
    "\n",
    "因为 jieba 是一个第三方库，所有需要我们在本地进行安装：\n",
    "\n",
    "ⅠIDLE中jieba库的安装：\n",
    "\n",
    "Windows 下使用命令安装：在联网状态下，在命令行下输入 pip\n",
    "\n",
    "install jieba 进行安装，安装完成后会提示安装成功。具体过程如图：\n",
    "\n",
    "①  Win + r 打开运行框并输入cmd打开指令框：\n",
    "\n",
    "![](https://upload-images.jianshu.io/upload_images/27009188-e3398fefefe2ed50.png)\n",
    "\n",
    "②在指令框输入“pip install jieba”并按下回车等待下载：\n",
    "\n",
    "![](https://upload-images.jianshu.io/upload_images/27009188-eac424490162784d.png)\n",
    "\n",
    "![](https://upload-images.jianshu.io/upload_images/27009188-799b6d8b7c0506a7.png)\n",
    "\n",
    "③ 当出现“Successfully instll”，则表示安装成功！\n",
    "\n",
    "### Ⅱ Pycharm中jieba库的安装：\n",
    "\n",
    "打开 settings，搜索 Project Interpreter，在右边的窗口选择 + 号，点击后在搜索框搜索 jieba，点击安装即可。具体过程如图：\n",
    "\n",
    "①  点击左上角Files中的Settings：\n",
    "\n",
    "![](https://upload-images.jianshu.io/upload_images/27009188-c13078d5e4724bb4.png)\n",
    "\n",
    "②  \\[endif\\]找到“Project”中的“python interpreter”，并点击其中的“+”：\n",
    "\n",
    "![](https://upload-images.jianshu.io/upload_images/27009188-0a357ed2b76f98c5.png)\n",
    "\n",
    "③在搜索栏中搜索“jieba”，并点击左下角Install Package：\n",
    "\n",
    "![](https://upload-images.jianshu.io/upload_images/27009188-1ebda5de9c20fbd8.png)\n",
    "\n",
    "④ 当出现“Successfully instll\n",
    "\n",
    "jieba”，则表示jieba库安装成功！\n",
    "\n",
    "#### 四：实例-文本词频统计\n",
    "\n",
    "Jieba库最强大的功能之一就是对文章出现的词汇进行计数统计，即计算词频，对于一篇文章或者一部著作，我们可以通过以下步骤对出现的单词进行统计：\n",
    "\n",
    "![](https://upload-images.jianshu.io/upload_images/27009188-041acc63529a9a0e.png)\n",
    "\n",
    "源代码："
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "\n",
    "![](https://upload-images.jianshu.io/upload_images/27009188-d6f432333e0c663d.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "曹躁        :  832\n",
      "孔明        :  831\n",
      "将军        :  757\n",
      "却说        :  645\n",
      "玄德        :  568\n",
      "关公        :  509\n",
      "丞相        :  487\n",
      "二人        :  465\n",
      "不可        :  435\n",
      "荆州        :  420\n",
      "孔明曰       :  385\n",
      "玄德曰       :  383\n",
      "不能        :  382\n",
      "如此        :  376\n",
      "张飞        :  348\n"
     ]
    }
   ],
   "source": [
    "import jieba\n",
    "\n",
    "txt = open(\"三国演义.txt\", \"r\",encoding=\"utf-8\").read()\n",
    "words = jieba.lcut(txt)\n",
    "counts = {}\n",
    "for word in words:\n",
    "    if len(word) == 1:\n",
    "        continue\n",
    "    else:\n",
    "        counts[word] = counts.get(word, 0) + 1\n",
    "items = list(counts.items())\n",
    "items.sort(key=lambda x: x[1], reverse=True)\n",
    "for i in range(15):\n",
    "    word, count = items[i]\n",
    "    print(f\"{word:<10}:{count:>5}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "\n",
    "注：\n",
    "\n",
    "①  encoding=’ANSI’:将打开的文本格式设为ANSI形式\n",
    "\n",
    "②  read(size):方法从文件当前位置起读取size个字节，若无参数size，则表示读取至文件结束为止，它范围为字符串对象。\n",
    "\n",
    "③items\n",
    "\n",
    "\\= list（counts.items）:将counts中的元素存入items表格中。\n",
    "\n",
    "④  key = lambda x:x\\[1\\]:等价于 def func(x):\n",
    "\n",
    "                                                          return x\\[1\\]\n",
    "\n",
    "⑤ reverse = True：列**表反转排序，**不写reverse = True 就是列表升序排列，括号里面加上reverse =True 就是降序排列！\n",
    "\n",
    "**⑥**  {word:<10}{count:>5}:**<****表示左对齐，>表示右对齐，数字表示宽度,<10表示左对齐，并占10个位置，>5表示右对齐，占5个位置。**\n",
    "\n",
    "如上运行结果有两个不足之处，一是词汇中出现了“却说”、“丞相”、“二人”等人名以外的单词，我们需要把这些单词去除；二是“孔明”与“孔明说”、“曹操”与“丞相”等的是同一人，我们需要把它们合并同类项，将代码进行优化后，我们得到："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "曹躁        :  832\n",
      "孔明        :  831\n",
      "玄德        :  568\n",
      "关公        :  509\n",
      "丞相        :  487\n",
      "孔明曰       :  385\n",
      "玄德曰       :  383\n",
      "张飞        :  348\n",
      "商议        :  344\n",
      "如何        :  336\n",
      "主公        :  327\n",
      "军士        :  309\n",
      "吕布        :  300\n",
      "大喜        :  296\n",
      "左右        :  291\n"
     ]
    }
   ],
   "source": [
    "import jieba\n",
    "\n",
    "excludes = {\"将军\", \"却说\", \"荆州\", \"二人\", \"不可\", \"不能\", \"如此\"}\n",
    "txt = open(\"三国演义.txt\", \"r\", encoding=\"utf-8\").read()\n",
    "words = jieba.lcut(txt)\n",
    "counts = {}\n",
    "for word in words:\n",
    "    if len(word) == 1:\n",
    "        continue\n",
    "    elif word == \"诸葛亮\" or word == \"孔明曰\":\n",
    "        rword = \"孔明\"\n",
    "    else:\n",
    "        rword = word\n",
    "    counts[word] = counts.get(word, 0) + 1\n",
    "for word in excludes:\n",
    "    del counts[word]\n",
    "items = list(counts.items())\n",
    "items.sort(key=lambda x: x[1], reverse=True)\n",
    "for i in range(15):\n",
    "    word, count = items[i]\n",
    "    print(f\"{word:<10}:{count:>5}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "\n",
    "\n",
    "\n",
    "\n",
    "相对于第一个程序，这个程序更为严谨与完整，已经得到了大致得到所需结果，但它还没有完全解决排除非人名这一问题，所以在该基础之上继续使用排除人名的方法去完善这一程序……\n",
    "\n",
    "#### 总结：\n",
    "\n",
    "使用jieba库对一段文本进行词频的统计是一件非常有意思的事，我们只需要使用这第三方库，就可以在不阅读文本的情况下，得到该文本的高频率词汇。但jieba库的作用远远不止于此，它更多的作用等着我们去挖掘。总的来说，jieba库是一个优秀的中文分词第三方库，它在我们的程序中正大放光芒！"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "pd.DataFrame(data = items).to_csv(r\"三国演义.csv\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## 1\\. 安装 wordcloud 模块\n",
    "\n",
    "1.  网络正常情况下命令行输入`pip install wordcloud`,如果提示报错按以下步骤进行安装\n",
    "\n",
    "```\n",
    "pip install wordcloud\n",
    "```\n",
    "\n",
    "2.  **pip**安装**wordcloud**过程中提示pip工具版本低,需pip-10.0.1版本，需先更新pip包管理工具：\n",
    "\n",
    "```\n",
    "python -m pip install --upgrade pip\n",
    "```\n",
    "\n",
    "3.  **pip**更新到最新版本后还是安装**wordcloud**报错\n",
    "\n",
    "先下载`wordcloud‑1.4.1‑cp36‑cp36m‑win_amd64.whl`安装包到本地目录, python为3.6.x版本的下载cp36的包，注意不要下cp37，安装不了的。\n",
    "\n",
    "4.  打开[命令行](https://so.csdn.net/so/search?q=%E5%91%BD%E4%BB%A4%E8%A1%8C&spm=1001.2101.3001.7020)窗口，进入到安装包所在目录位置如 `D:\\download`\n",
    "\n",
    "5.  输入\n",
    "\n",
    "\n",
    "```\n",
    "pip install wordcloud-1.4.1-cp36-cp36m-win_amd64.whl\n",
    "```\n",
    "\n",
    "回车安装即可。\n",
    "\n",
    "## 2\\. wordcloud 简介\n",
    "\n",
    "**wordcloud** 库把词云当作一个**WordCloud**对象\n",
    "\n",
    "-   `wordcloud.WordCloud()` 代表一个文本对应的词云\n",
    "-   可以根据文本中词语出现的频率等参数绘制词云\n",
    "-   绘制词云的形状、尺寸和颜色均可设定\n",
    "-   以WordCloud对象为基础，配置参数、加载文本、输出文件\n",
    "\n",
    "```\n",
    "c = wordcloud.WordCloud()  # 配置对象参数\n",
    "c.generate(\"wordcloud by python\")  # 加载词云文本\n",
    "c.to_file(\"pywordcloud.png\")  # 输出词云文件\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from wordcloud import WordCloud\n",
    "c = WordCloud(font_path='simhei.ttf').generate(\"中文 by 测试\")\n",
    "import matplotlib.pyplot as plt\n",
    "plt.imshow(c)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "\n",
    "![在这里插入图片描述](https://img-blog.csdnimg.cn/b67ddd1295964bce94a842c7318f90f2.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2MDkyMDYx,size_16,color_FFFFFF,t_70)\n",
    "\n",
    "## 3\\. wordcloud 如何将文本转化为词云\n",
    "\n",
    "1.  **分隔**：以空格分隔单词\n",
    "2.  **统计**：单词出现次数并过滤\n",
    "3.  **字体**：根据统计配置字号\n",
    "4.  **布局**：颜色环境尺寸\n",
    "\n",
    "## 4\\. WordCloud(<参数>)介绍\n",
    "\n",
    "1.  **width**：指定词云对象生成图片的宽度,默认400像素\n",
    "\n",
    "```\n",
    "w=wordcloud.WordCloud(width=600)\n",
    "```\n",
    "\n",
    "2.  **height**：指定词云对象生成图片的高度,默认200像素\n",
    "\n",
    "```\n",
    "w=wordcloud.WordCloud(height=400)\n",
    "```\n",
    "\n",
    "3.  **min\\_font\\_size**：指定词云中字体的最小字号，默认4号\n",
    "\n",
    "```\n",
    "w=wordcloud.WordCloud(min_font_size=10)\n",
    "```\n",
    "\n",
    "4.  **max\\_font\\_size**：指定词云中字体的最大字号，根据高度自动调节\n",
    "\n",
    "```\n",
    "w=wordcloud.WordCloud(max_font_size=20)\n",
    "```\n",
    "\n",
    "5.  **font\\_step**：指定词云中字体字号的步进间隔，默认为1\n",
    "\n",
    "```\n",
    "w=wordcloud.WordCloud(font_step=2)\n",
    "```\n",
    "\n",
    "6.  **font\\_path**：指定文体文件的路径，默认None\n",
    "\n",
    "```\n",
    "w=wordcloud.WordCloud(font_path=\"msyh.ttc\")\n",
    "```\n",
    "\n",
    "7.  **max\\_words**：指定词云显示的最大单词数量,默认200\n",
    "\n",
    "```\n",
    "w=wordcloud.WordCloud(max_words=20)\n",
    "```\n",
    "\n",
    "8.  **stop\\_words**：指定词云的排除词列表，即不显示的单词列表\n",
    "\n",
    "```\n",
    "w=wordcloud.WordCloud(stop_words=\"Python\")\n",
    "```\n",
    "\n",
    "9.  **mask**：指定词云形状，默认为长方形，需要引用`imread()`函数\n",
    "\n",
    "```\n",
    "from scipy.msc import imread\n",
    "\n",
    "mk=imread(\"pic.png\")\n",
    "w=wordcloud.WordCloud(mask=mk)\n",
    "```\n",
    "\n",
    "10.  **background\\_color**：指定词云图片的背景颜色，默认为黑色\n",
    "    `w=wordcloud.WordCloud(background_color=\"white\")`\n",
    "\n",
    "**示例：**\n",
    "\n",
    "```\n",
    "text = \"life is short, you need python\"\n",
    "\n",
    "w = wordcloud.WordCloud(background_color=\"white\")  # 把词云当做一个对象\n",
    "w.generate(text)\n",
    "w.to_file(\"pywordcloud2.png\")\n",
    "```\n",
    "\n",
    "![在这里插入图片描述](https://img-blog.csdnimg.cn/61ca7cc86734439bb15d16f306715525.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2MDkyMDYx,size_16,color_FFFFFF,t_70)\n",
    "\n",
    "## 5\\. 词云绘制1\n",
    "\n",
    "![在这里插入图片描述](https://img-blog.csdnimg.cn/8626af9271b04d39937d7fdfc53c7841.png)\n",
    "\n",
    "`关于实施乡村振兴战略的意见.txt`\n",
    "\n",
    "```\n",
    "import jieba\n",
    "import imageio\n",
    "from wordcloud import WordCloud\n",
    "\n",
    "'''\n",
    "jieba支持三种分词模式：\n",
    "    精确模式lcut()，试图将句子最精确地切开，适合文本分析，单词无冗余；\n",
    "    全模式lcut(s, cut_all=True) ，把句子中所有的可以成词的词语都扫描出来, 速度非常快，但是不能解决歧义，存在冗余；\n",
    "    搜索引擎模式cut_for_search(s)，在精确模式的基础上，对长词再次切分，提高召回率，适合用于搜索引擎分词。\n",
    "'''\n",
    "\n",
    "with open(\"关于实施乡村振兴战略的意见.txt\", \"r\") as f:\n",
    "    allSentence = f.read()\n",
    "\n",
    "print(allSentence)\n",
    "\n",
    "re_move = ['，', '。', '\\n', '\\xa0', '-', '(', ')']  # 无效数据\n",
    "\n",
    "# 去除无关数据\n",
    "for i in re_move:\n",
    "    allSentence = allSentence.replace(i, \"\")\n",
    "\n",
    "pureWord = jieba.lcut(allSentence)\n",
    "\n",
    "with open(\"pureRuralRevitalieztion.txt\", \"w\") as f:\n",
    "     for i in pureWord:\n",
    "         f.write(str(i)+\" \")  # == ' '.join(pureWord)，以空格拼接list中元素\n",
    "\n",
    "with open(\"pureRuralRevitalieztion.txt\", \"r\") as f:\n",
    "    pureWord = f.read()\n",
    "\n",
    "# 获取一张背景图片\n",
    "mask = imageio.imread(\"chinamap.jpg\")\n",
    "word = WordCloud(background_color=\"white\",\\\n",
    "                    width=800,\\\n",
    "                   height=800,\n",
    "                   font_path='simhei.ttf',\n",
    "                   mask=mask,\n",
    "                   ).generate(pureWord)\n",
    "\n",
    "word.to_file('乡村振兴词云.png')\n",
    "\n",
    "# with open(\"pureRuralRevitalieztion.txt\", \"w\") as f:\n",
    "#     for i in pureWord:\n",
    "#         f.write(i+\" \")\n",
    "#\n",
    "#\n",
    "# c = wordcloud.WordCloud()  # 配置对象参数\n",
    "# c.generate(allSentence)\n",
    "# c.to_file(\"ruralRevitalieztion.png\")\n",
    "```\n",
    "\n",
    "## 6\\. 词云绘制2\n",
    "\n",
    "`新时代中国特色社会主义.txt`\n",
    "![在这里插入图片描述](https://img-blog.csdnimg.cn/f6d5900b1fb34e78b91eeb60e3938df0.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ2MDkyMDYx,size_16,color_FFFFFF,t_70)\n",
    "\n",
    "```\n",
    "import jieba\n",
    "import imageio\n",
    "from wordcloud import WordCloud\n",
    "\n",
    "with open(\"新时代中国特色社会主义.txt\", \"r\") as f:\n",
    "    allSentence = f.read()\n",
    "\n",
    "print(allSentence)\n",
    "\n",
    "re_move = ['，', '。', '\\n', '\\xa0', '-', '(', ')']  # 无效数据\n",
    "\n",
    "# 去除无关数据\n",
    "for i in re_move:\n",
    "    allSentence = allSentence.replace(i, \"\")\n",
    "\n",
    "pureWord = jieba.lcut(allSentence)\n",
    "\n",
    "with open(\"pureChinaDevelop.txt\", \"w\") as f:\n",
    "     for i in pureWord:\n",
    "         f.write(str(i)+\" \")\n",
    "\n",
    "with open(\"pureChinaDevelop.txt\", \"r\") as f:\n",
    "    pureWord = f.read()\n",
    "\n",
    "mask = imageio.imread(\"chinamap.jpg\")\n",
    "word = WordCloud(background_color=\"black\",\n",
    "                   width=800,\n",
    "                   height=800,\n",
    "                   font_path='simhei.ttf',\n",
    "                   mask=mask,\n",
    "                   ).generate(pureWord)\n",
    "\n",
    "word.to_file('新时代中国词云.png')\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "# 插入空格把词语分开\n",
    "items = items[:15]\n",
    "wc = []\n",
    "for item in items:\n",
    "    wc.append(item[0])\n",
    "wl_split=' '.join(wc)\n",
    "# 调用generate()方法生成词云\n",
    "from wordcloud import WordCloud\n",
    "mywc = WordCloud(font_path='simhei.ttf').generate(wl_split)\n",
    "mywc.to_file(\"三国词云.png\")\n",
    "# 显示词云\n",
    "import matplotlib.pyplot as plt\n",
    "plt.imshow(mywc)\n",
    "plt.axis('off')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}